//
// Created on 2025/11/18.
// Author 秦光磊.

#include "function/my_function.h"
#include "constant/constant.h"
#include <algorithm>
#include <hilog/log.h>
#include <vector>

int64_t MyFunction::ParseId(napi_env env, napi_callback_info info) {
    if ((env == nullptr) || (info == nullptr)) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "MyFunction", "ParseId,env or info is null.");
        return -1;
    }
    size_t argc = 1;
    napi_value args[1] = {nullptr};
    if (napi_ok != napi_get_cb_info(env, info, &argc, args, nullptr, nullptr)) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "MyFunction", "ParseId,GetContext napi_get_cb_info failed.");
        return -1;
    }
    int64_t value = 0;
    bool lossless = true;
    if (napi_ok != napi_get_value_bigint_int64(env, args[0], &value, &lossless)) {
        OH_LOG_Print(LOG_APP, LOG_ERROR, LOG_PRINT_DOMAIN, "MyFunction", "ParseId,Get value failed");
        return -1;
    }
    return value;
}

std::vector<int> MyFunction::GenElectronDistributionData(int electronCount) {
    OH_LOG_Print(LOG_APP, LOG_DEBUG, LOG_PRINT_DOMAIN, "MyFunction", "%{public}s start.", __func__);
    // 原子序号或者核外电子数，最少为1
    if (electronCount < 1) {
        electronCount = 1;
    }
    // 原子序号或者核外电子数，当前最多为118
    if (electronCount > 118) {
        electronCount = 118;
    }
    // 1s轨道电子数量
    int orbitElectronCount_1s;
    // 核外电子排布顺序：1s ,2s ,2p ,3s , 3p , 4s ,3d ,4p ,5s ,4d ,5p ,6s ,4f ,5d ,6p ,5f ,6d ,7s
    //-------------1s start ------------------------------------------------------------------//
    // 电子数大于0，此时进行1s轨道填充操作，1s轨道最多填充2个电子
    orbitElectronCount_1s = std::min(electronCount, 2);
    //-------------1s end --------------------------------------------------------------------//

    //-------------2s start ------------------------------------------------------------------//
    // 电子填满1s轨道后，剩余的电子数
    electronCount = electronCount - orbitElectronCount_1s;
    // 2s轨道电子数量
    int orbitElectronCount_2s = 0;
    if (electronCount > 0) {
        // 电子数大于0，此时进行2s轨道填充操作，2s轨道最多填充2个电子
        orbitElectronCount_2s = std::min(electronCount, 2);
    }
    //-------------2s end --------------------------------------------------------------------//

    //-------------2p start ------------------------------------------------------------------//
    // 电子填满2s轨道后，剩余的电子数
    electronCount = electronCount - orbitElectronCount_2s;
    // 2p轨道电子数量
    int orbitElectronCount_2p;
    orbitElectronCount_2p = 0;
    if (electronCount > 0) {
        // 电子数大于0，此时进行2p轨道填充操作，2p轨道最多填充6个电子
        orbitElectronCount_2p = std::min(electronCount, 6);
    }
    //-------------2p end --------------------------------------------------------------------//

    //-------------3s start ------------------------------------------------------------------//
    // 电子填满2p轨道后，剩余电子数
    electronCount = electronCount - orbitElectronCount_2p;

    // 3s轨道电子数量
    int orbitElectronCount_3s = 0;
    if (electronCount > 0) {
        // 电子数大于0，此时进行3s轨道填充操作，3s轨道最多填充2个电子
        orbitElectronCount_3s = std::min(electronCount, 2);
    }
    //-------------3s end --------------------------------------------------------------------//

    //-------------3p start ------------------------------------------------------------------//
    // 电子填满3s轨道后，剩余电子数
    electronCount = electronCount - orbitElectronCount_3s;
    // 3p轨道电子数量
    int orbitElectronCount_3p = 0;
    if (electronCount > 0) {
        // 电子数大于0，此时进行3p轨道填充操作，3p轨道最多填充6个电子
        orbitElectronCount_3p = std::min(electronCount, 6);
    }
    //-------------3p end --------------------------------------------------------------------//

    //-------------3d 4s start----------------------------------------------------------------//
    // 电子填满3p轨道后，剩余电子数
    electronCount = electronCount - orbitElectronCount_3p;
    // 4s轨道电子数量
    int orbitElectronCount_4s = 0;
    // 3d轨道电子数量
    int orbitElectronCount_3d = 0;
    if (electronCount > 0) { // 电子数大于0，将填充3d，4s
        switch (electronCount) {
        case 1:
        case 2:
            // 若剩余的电子数为1或者2，d1不如s1（半）稳定，更不如s2（全满）稳定，所以若剩余电子数小于等于2时，将优先填充到高一点能级4s轨道上去，保持能级稳定
            orbitElectronCount_4s = electronCount; // 对4s轨道进行电子填充
            break;
        case 3:
        case 4:
        case 5:
        case 7:
        case 8:
        case 9:
        case 10:
            // 若剩余电子数为3或者4或者5，此时将2个电子填入到4s后，剩余的电子将填入到3d
            // 若剩余电子数据为7或者8或者9，此时将4s填充为4s2全充满，3d填充为3d5后，剩余的电子将按照低能级分配原则进入3d
            orbitElectronCount_4s = 2;                                     // 先将4s填充为全充满状态
            orbitElectronCount_3d = electronCount - orbitElectronCount_4s; // 剩余的电子将填充到3d轨道
            break;
        case 6:
            // 若剩余电子数为6，此时恰好可以触发3d轨道与4s轨道的半充满状态，足够稳定
            orbitElectronCount_3d = 5; // 3d5半充满
            orbitElectronCount_4s = 1; // 4s1半充满
            break;
        case 11:
        case 12:
            // 若剩余电子数据为11、12，则将触发3d10的全充满状态，剩余的填入4s
            orbitElectronCount_3d = 10;                                    // 3d10全充满
            orbitElectronCount_4s = electronCount - orbitElectronCount_3d; // 4s填充1到两个电子
            break;
        default:
            // 若剩余电子数据大于等于13，则将触发3d10的全充满状态，以及4s2的全充满状态，剩余的将填充后面的轨道
            orbitElectronCount_4s = 2;  // 4s2全充满
            orbitElectronCount_3d = 10; // 3d10全充满
            break;
        }
    }
    //-------------3d 4s end -----------------------------------------------------------------//

    //--------------- 4p start----------------------------------------------------------------//
    electronCount = electronCount - orbitElectronCount_3d - orbitElectronCount_4s; // 电子填满3d，4s轨道后，剩余电子数
    // 4p轨道电子数量
    int orbitElectronCount_4p = 0;
    if (electronCount > 0) {
        // 电子数大于0，将填充4p，4p轨道最多填充6个电子
        orbitElectronCount_4p = std::min(electronCount, 6);
    }
    //--------------- 4p end------------------------------------------------------------------//

    //--------------- 4d 5s start-------------------------------------------------------------//
    electronCount = electronCount - orbitElectronCount_4p; // 电子填满4p轨道后，剩余电子数
    // 5s轨道电子数量
    int orbitElectronCount_5s = 0;
    // 4d轨道电子数量
    int orbitElectronCount_4d = 0;
    if (electronCount > 0) { // 电子数大于0，将填充4d与5s
        switch (electronCount) {
        case 1:
        case 2:
            // 若剩余的电子数为1或者2，d1不如s1（半）稳定，更不如s2（全满）稳定，所以若剩余电子数小于等于2时，将优先填充到高一点能级5s轨道上去，保持能级稳定
            orbitElectronCount_5s = electronCount; // 对4s轨道进行电子填充
            break;
        case 3:
        case 4:
            // 若剩余电子数为3或者4，此时将2个电子填入到5s后，剩余的电子将填入到4d
            orbitElectronCount_5s = 2;                                     // 先将5s填充为全充满状态
            orbitElectronCount_4d = electronCount - orbitElectronCount_5s; // 剩余的电子将填充到4d轨道
            break;
        case 5:
            // 若剩余电子数为5，此时5s将填充1个电子，剩余4个电子填充给到4d--------该结果由光谱实验测试得出
            orbitElectronCount_5s = 1; // 特殊处理，对于铌元素，5s轨道填充1个电子
            orbitElectronCount_4d = 4; // 特殊处理，对于铌元素，4d轨道填充4个电子
            break;
        case 6:
            // 若剩余电子数为6，此时恰好可以触发4d轨道与5s轨道的半充满状态，足够稳定
            orbitElectronCount_4d = 5; // 4d5半充满
            orbitElectronCount_5s = 1; // 5s1半充满
            break;
        case 7:
            // 若剩余电子数为7，此时恰好可以触发4d轨道半充满与5s轨道的全充满状态，足够稳定
            orbitElectronCount_4d = 5; // 4d5半充满
            orbitElectronCount_5s = 2; // 5s2全充满
            break;
        case 8:
            // 若剩余电子数为8，此时5s将填充1个电子，剩余7个电子填充给到4d--------该结果由光谱实验测试得出
            orbitElectronCount_4d = 7; // 特殊处理，对于钌元素，4d轨道填充7个电子
            orbitElectronCount_5s = 1; // 特殊处理，对于钌元素，5s轨道填充1个电子
            break;
        case 9:
            // 若剩余电子数为9，此时5s将填充1个电子，剩余8个电子填充给到4d--------该结果由光谱实验测试得出
            orbitElectronCount_4d = 8; // 特殊处理，对于铑元素，4d轨道填充8个电子
            orbitElectronCount_5s = 1; // 特殊处理，对于铑元素，5s轨道填充1个电子
            break;
        case 10:
            // 若剩余电子数为10，此时触发4d轨道全充满状态，电子全部填入4d轨道
            orbitElectronCount_4d = 10; // 特殊处理，对于铑元素，4d轨道填充10个电子
            break;
        case 11:
        case 12:
            // 若剩余电子数据为11，12，则将触发4d10的全充满状态，剩余电子填入5s
            orbitElectronCount_4d = 10;                                    // 4d填充10个电子
            orbitElectronCount_5s = electronCount - orbitElectronCount_4d; // 剩余的填充到5s
            break;
        default:
            // 若剩余电子数大于等于13：orbitElectronCount_4d填充10个电子，orbitElectronCount_5s填充2个电子，剩余的将进入下一层轨道
            orbitElectronCount_4d = 10;
            orbitElectronCount_5s = 2;
        }
    }
    //--------------- 4d 5s end---------------------------------------------------------------//

    //----------------5p start----------------------------------------------------------------//
    electronCount = electronCount - orbitElectronCount_4d - orbitElectronCount_5s; // 电子填满4d\5s轨道后，剩余电子数
    // 电子数大于0，将填充5p
    // 5p轨道电子数量
    int orbitElectronCount_5p = 0;
    // 5p轨道最多填充6个电子
    if (electronCount > 0)
        orbitElectronCount_5p = std::min(electronCount, 6);
    //----------------5p end  ----------------------------------------------------------------//


    //----------------4f 5d 6s start----------------------------------------------------------//
    electronCount = electronCount - orbitElectronCount_5p; // 电子填满5p轨道后，剩余电子数

    // 6s轨道电子数量
    int orbitElectronCount_6s = 0;
    // 5d轨道电子数量
    int orbitElectronCount_5d = 0;
    // 4f轨道电子数量
    int orbitElectronCount_4f = 0;
    if (electronCount > 0) { // 剩余电子数大于0，将填充4f、5d、6s
        switch (electronCount) {
        case 1:
        case 2:                                    // 对应元素铯（55）、钡（56）
            orbitElectronCount_6s = electronCount; // 若剩余电子数为1,2,电子优先占据6s轨道形成6s1、6s2
            break;
        case 3: // 对应元素镧（57）
            // 若剩余电子数为3，则6s轨道填充2电子后，剩余1电子将填充到5d轨道
            orbitElectronCount_6s = 2;
            orbitElectronCount_5d = 1;
            break;
        case 4: // 对应元素铈（58）
            // 若剩余电子数为4，则6s轨道填充2电子后，剩余2电子，将分别填充到5d轨道与4f轨道
            orbitElectronCount_6s = 2;
            orbitElectronCount_5d = 1;
            orbitElectronCount_4f = 1;
            break;
        case 5: // 对应元素镨（59）
            // 若剩余电子数为5，则6s轨道填充2电子后，剩余3电子，将填充到4f轨道
            orbitElectronCount_6s = 2;
            orbitElectronCount_4f = 3;
            break;
        case 10:
            // 对应元素，钆(64)
            // 钆的4f轨道占7个电子，半充满
            orbitElectronCount_6s = 2;
            orbitElectronCount_5d = 1;
            orbitElectronCount_4f = electronCount - orbitElectronCount_6s - orbitElectronCount_5d;
            break;
        case 6:
        case 7:
        case 8:
        case 9:
        case 11:
        case 12:
        case 13:
        case 14:
        case 15:
        case 16:
            // 对应元素，钕(60)、钜(61)、钐(62)、铕(63)、铽(65)、镝(66)、钬(67)、铒(68)、铥(69)、镱(70)
            // 若剩余电子数为6~16，则6s轨道填充2电子后，剩余的4~14个电子将依次填充到4f
            orbitElectronCount_6s = 2;
            orbitElectronCount_4f = electronCount - orbitElectronCount_6s;
            break;
        case 17:
        case 18:
        case 19:
        case 20:
        case 21:
        case 22:
        case 23: // 对应镥(71)、铪(72)、钽(73)、钨(74)、铼(75)、锇(76)、铱(77)
            // 若剩余电子数为17~23，则6s轨道填充2电子后，4f轨道填充14电子后，剩余的1~7个电子将进入5d轨道
            orbitElectronCount_6s = 2;
            orbitElectronCount_4f = 14;
            orbitElectronCount_5d = electronCount - orbitElectronCount_6s - orbitElectronCount_4f;
            break;
        case 24: // 对应铂(78)
            // 若剩余电子数为24，则4f轨道填充14电子后，剩余10个电子，1个进入6s轨道，另外9个进入5d轨道
            orbitElectronCount_6s = 1;
            orbitElectronCount_4f = 14;
            orbitElectronCount_5d = 9;
            break;
        case 25: // 对应金(79) case 26://对应汞(80)
            // 若剩余电子数为25，则4f轨道填充14电子后，5d轨道填充,剩余10个电子填入5d轨道，另外1到2个个进入6s轨道
            orbitElectronCount_4f = 14;
            orbitElectronCount_5d = 10;
            orbitElectronCount_6s = electronCount - orbitElectronCount_4f - orbitElectronCount_5d;
            break;
        default:
            // 若剩余电子数大于等于25，则4f轨道填充14电子后，5d轨道填充10个电子,6s轨道将填充2个电子，剩余将填充到后面的轨道
            orbitElectronCount_4f = 14;
            orbitElectronCount_5d = 10;
            orbitElectronCount_6s = 2;
            break;
        }
    }
    //----------------4f 5d 6s end------------------------------------------------------------//

    //----------------6p start----------------------------------------------------------------//
    electronCount = electronCount - orbitElectronCount_4f - orbitElectronCount_5d -
                    orbitElectronCount_6s; // 电子填满4f\5d\6s轨道后，剩余电子数
    // 6p轨道电子数量
    int orbitElectronCount_6p = 0;
    if (electronCount > 0) { // 电子数大于0，将填充6p
        // 6p轨道最多填充6个电子
        orbitElectronCount_6p = std::min(electronCount, 6); // 对6p轨道进行电子填充
    }
    //----------------6p end  ----------------------------------------------------------------//

    //----------------5f 6d 7s start----------------------------------------------------------//
    electronCount = electronCount - orbitElectronCount_6p; // 电子填满6p轨道后，剩余电子数
    // 7s轨道电子数量
    int orbitElectronCount_7s = 0;
    // 6d轨道电子数量
    int orbitElectronCount_6d = 0;
    // 5f轨道电子数量
    int orbitElectronCount_5f = 0;
    if (electronCount > 0) { // 剩余电子数大于0，将填充5f 6d 7s
        switch (electronCount) {
        case 1:
        case 2:                                    // 对应元素钫（87）、镭（88）
            orbitElectronCount_7s = electronCount; // 若剩余电子数为1,2,电子优先占据7s轨道形成7s1、7s2
            break;
        case 3:
        case 4: // 对应元素锕（89）、对应元素钍（90）
            // 若剩余电子数为3、4，则7s轨道填充2电子后，剩余1到2个电子将填充到6d轨道
            orbitElectronCount_7s = 2;
            orbitElectronCount_6d = electronCount - orbitElectronCount_7s;
            break;
        case 5:
        case 6:
        case 7:
            // 对应元素镤（91）、铀（92）、镎（93）
            // 若剩余电子数为5、6、7，则7s轨道填充2电子后，6d轨道填充1个电子，剩余的电子将填充到5f
            orbitElectronCount_7s = 2;
            orbitElectronCount_6d = 1;
            orbitElectronCount_5f = electronCount - orbitElectronCount_6d - orbitElectronCount_7s;
            break;
        case 8:
        case 9:
            // 对应元素，钚(94)、镅(95)
        case 11:
        case 12:
        case 13:
        case 14:
        case 15:
        case 16:
            // 对应锫(97)、锎（98）、锿（99）、镄（100）、钔（101）、锘（102）
            // 若剩余电子数为8、9、11、12、13、14、15、16，则7s轨道填充2电子后，剩余的电子填入5f轨道
            orbitElectronCount_7s = 2;
            orbitElectronCount_5f = electronCount - orbitElectronCount_7s;
            break;
        case 10: // 对应锔(96)
            // 若剩余电子数为10，则7s轨道填充2电子后，5f轨道填充7电子,6d轨道填充1电子
            orbitElectronCount_7s = 2;
            orbitElectronCount_5f = 7;
            orbitElectronCount_6d = 1;
            break;
        case 17:
        case 18:
        case 19:
        case 20:
        case 21:
        case 22:
        case 23:
        case 24:
        case 25:
        case 26:
            // 对应铹(103)、钅卢（104）、钅杜（105）、钅喜（106）、钅波（107）、钅黑（108）、钅麦（109）、
            // 钅达（110）、钅仑（111）、钅哥（112）、钅尔（113）、钅夫（104）、钅莫（115）、钅立（116）、石田（117）、气奥（118）
            // 若剩余电子数为17~26，则7s轨道填充2个电子，5f轨道填充14个电子，6d轨道填充1到10个电子
            orbitElectronCount_7s = 2;
            orbitElectronCount_5f = 14;
            orbitElectronCount_6d = electronCount - orbitElectronCount_7s - orbitElectronCount_5f;
            break;
        default:
            // 若剩余电子数大于等于27，orbitElectronCount_7s填充两个电子，orbitElectronCount_5f填充14个电子，orbitElectronCount_6d填充10个电子，剩余的将进入后面的轨道
            orbitElectronCount_7s = 2;
            orbitElectronCount_5f = 14;
            orbitElectronCount_6d = 10;
            break;
        }
    }
    //----------------5f 6d 7s end------------------------------------------------------------//

    //----------------7p start----------------------------------------------------------------//
    electronCount = electronCount - orbitElectronCount_5f - orbitElectronCount_6d -
                    orbitElectronCount_7s; // 电子填满5f\6d\7s轨道后，剩余电子数
    // 7p轨道电子数量
    int orbitElectronCount_7p = 0;
    if (electronCount > 0) { // 电子数大于0，将填充7p
        // 6p轨道最多填充6个电子
        orbitElectronCount_7p = std::min(electronCount, 6); // 对7p轨道进行电子填充
    }
    //----------------7p end  ----------------------------------------------------------------//

    // 数组有20个元素，其中第一个元素值为0，无任何业务意义，只为加个0，使得后面的数组元素能更好地对应业务意义。
    // 例如orbitElectronCount[1]就表示第一个轨道上电子数，orbitElectronCount[5]就表示第5个轨道上电子数，无须管orbitElectronCount[0]业务意思
    std::vector<int> orbitElectronCount = {0,
                                           orbitElectronCount_1s,
                                           orbitElectronCount_2s,
                                           orbitElectronCount_2p,
                                           orbitElectronCount_3s,
                                           orbitElectronCount_3p,
                                           orbitElectronCount_3d,
                                           orbitElectronCount_4s,
                                           orbitElectronCount_4p,
                                           orbitElectronCount_4d,
                                           orbitElectronCount_4f,
                                           orbitElectronCount_5s,
                                           orbitElectronCount_5p,
                                           orbitElectronCount_5d,
                                           orbitElectronCount_5f,
                                           orbitElectronCount_6s,
                                           orbitElectronCount_6p,
                                           orbitElectronCount_6d,
                                           orbitElectronCount_7s,
                                           orbitElectronCount_7p};

    return orbitElectronCount;
}
